<?php

class Uri {
    private static $urlPage;
    private static $alias = FALSE;
    private static $class;
    private static $method;
    private static $security;
    private static $POST = NULL;
    private static $GET = NULL;
    private static $REST = NULL;
    private static $SERVER = NULL;

    public static function setURI() {

        $urlTokens = explode('?', $_SERVER['REQUEST_URI']);
        $urlTokens = explode('/', $urlTokens[0]);

        self::$urlPage = array_slice($urlTokens, 1, count($urlTokens) - 1);
        
        // Recupera os valores passados
        self::setParams();

        //Execua a açao de acordo com a URL
        self::setAction();
    }
    
    private static function setAction() {
        switch (self::$urlPage[0]) {
            case 'tws':
                self::$security = '1';
                TWS::handleWS(self::$urlPage[1]);
                break;
            case 'rest':
                self::$security = '2';
                $r = new Restler();
                $r->addAPIClass('CepController', '');
                $r->setSupportedFormats('JsonFormat', 'XmlFormat', 'yamlformat', 'plistformat', 'amfformat');
                $r->addAuthenticationClass('SimpleAuth');
                $r->handle();
                break;
            case 'service':
                self::$security = '3';
                break;
            default :
                self::$security = '4';
            
                if (self::setClass()) {
                    Controller::exec();
                } else {
                  $restauranteModel = new RestauranteModel();
                  $restaurante = $restauranteModel->buscarRestaurantePorUrl(self::$urlPage[0]);
                  if($restaurante){
                    header("Location: /produtos/".self::$urlPage[0]."/".$restaurante['id']);
                  }
                  self::$class = 'HomeController';
                  self::$method = 'Erro';

                  Controller::exec();
                }
                break;
        }
    }

    /**
     * Define a classe que sera executado e retorna true ou false;
     * @return boolean 
     */
    private static function setClass() {
        //Pega os Alias definidos no sistema;
        $routes = Route::getRoutes();
        //Define o nome da classe;
        $class = self::$urlPage[0];

        // Se a Classe for vazia ele define uma classe e metodo padrão.
        if (empty($class)) {
            self::$class = 'HomeController';
            self::$method = 'index';

            return true;
        } else { // se for diferente de vazio 
            // Verifica se existe um alias para a classe passada na url
            if (array_key_exists($class, $routes)) {
                self::$alias = true;
                self::$class = $routes[$class]['controller'];
            } else { // se não existir define o parametro da url como classe
                self::$class = ucfirst($class) . 'Controller';
            }
        }

        // Verifica se a classe existe
        if (self::checkClass()) {
            //Verifica se o methodo existe
            if (self::setMethod()) {
                return true;
            } else { // se metodo não existir retorna false
                return false;
            };
        } else { // se a classe não existir retorna false
            return false;
        }
    }

    /**
     * Define o metodo que sera executado e retorna true ou false;
     * @return boolean 
     */
    private static function setMethod() {
        $routes = Route::getRoutes();
        $class = self::$urlPage[0];

        // Se a $urlPage possuir mais de 1 parametro
        if (count(self::$urlPage) > 1) {
            self::$method = self::$urlPage[1];
            // se methodo não existir
            if (!self::checkMethod()) {
                if (self::$alias) {
                    self::$method = $routes[$class]['method'];
                    return (self::checkMethod()) ? true : false;
                } else {
                    return false;
                }
            }

            return true;
        } else { // se a $urlPage for menor ou igual a 1 e pq nao foi passado o metodo pela url
            self::$method = (self::$alias) ? $routes[$class]['method'] : 'index';

            if (!self::checkMethod()) {
                return false;
                self::$method = 'index';
            }

            return true;
        }
    }

    private static function setParams() {

        // Se existir algum parametro passado via POST percorremos
        // e montamos um array associativo com todos os parametos.
        if (isset($_POST)) {
            $getObject = array();
            foreach ($_POST as $chave => $valor) {
            	if($chave == 'json'){
            		$valor = str_replace("\\", "", $valor);
            		$valor = json_decode($valor);
					$getObject[$chave] = $valor;
            	}else{
            		$getObject[$chave] = $valor;
				}	
            }
            self::$POST = $getObject;
        }
        // Se existir algum parametro passado via POST percorremos
        // e montamos um array associativo com todos os parametos.
        if (isset($_GET)) {
            $getObject = array();
            foreach ($_GET as $chave => $valor) {
                $getObject[$chave] = $valor;
            }
            self::$GET = $getObject;
        }
        //Se o parametro for passado via PUT / DELETE recuperamos com file_fet_contents
        parse_str(file_get_contents("php://input"), $post_vars);
        if (isset($post_vars['data'])) {
            $info = $post_vars['data'];
            self::$REST = json_decode(stripslashes($info));
        }
        // Pega os parametros do Servidor
        // e montamos um array associativo com todos os parametos.
        if (isset($_SERVER)) {
            $getObject = array();
            foreach ($_SERVER as $chave => $valor) {
                $getObject[$chave] = $valor;
            }
            self::$SERVER = $getObject;
        }
    }

    /**
     * Verifica se a classe existe
     * @return boolean 
     */
    private static function checkClass() {
        return (class_exists(self::$class)) ? true : false;
    }

    /**
     * Verifica se o metodo existe
     * @return boolean 
     */
    private static function checkMethod() {
        $class = new self::$class;

        if (method_exists($class, self::$method)) {
            $class = null;
            return true;
        } else {
            $class = null;
            return false;
        }
    }

    /**
     * Retorna a classe;
     * @return string classe 
     */
    public static function getClass() {
        return self::$class;
    }

    /**
     * Retorna o Metodo
     * @return String Metodo
     */
    public static function getMethod() {
        return self::$method;
    }

    /*
     * Retorna os parametros passados via POST
     * @return Array associativo
     */

    public static function getPOST($value = NULL) {
    	
        if (!is_null($value)) {
            return key_exists($value, self::$POST) ? self::$POST[$value] : FALSE;
        }

        return self::$POST;
    }

    /*
     * Retorna os parametros passados via GET
     * @return Array associativo
     */

    public static function getGET($value = NULL) {

        if (!is_null($value)) {
            return key_exists($value, self::$GET) ? self::$GET[$value] : FALSE;
        }

        return self::$GET;
    }

    /*
     * Retorna os parametros passados via PUT/DELETE
     * @return Array associativo
     */
    public static function getREST() {
        return self::$REST;
    }

    /*
     * Retorna os parametros do servidor - SERVER
     * @return Array associativo
     */

    public static function getSERVER($value = NULL) {
        return self::$SERVER;
    }

    /*
     * Retorna o usuario passado via auth
     * @return Array associativo
     */

    public static function getAuthUser() {
        return isset(self::$SERVER['PHP_AUTH_USER']) ? self::$SERVER['PHP_AUTH_USER'] : FALSE;
    }

    /*
     * Retorna a senha passado via auth
     * @return Array associativo
     */

    public static function getAuthPw() {
        return isset(self::$SERVER['PHP_AUTH_PW']) ? self::$SERVER['PHP_AUTH_PW'] : FALSE;
    }
    
    public static function getTypeSecurity() {
        return self::$security;
    }
    
    public static function getUri($key = NULL){
    	if(!is_null($key)){
    		return self::$urlPage[$key];
    	}
    	return self::$urlPage;
    }

}

?>